{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "99f3bafa",
   "metadata": {},
   "source": [
    "# K-近邻算法（KNN）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a59c531a",
   "metadata": {},
   "source": [
    "k近邻算法，工作原理是：存在一个样本数据集，也叫训练样本集，并且每个样本都存在标签（预先知道样本属于哪个分类）。在输入新数据（没有带标签）后，将新数据中的每个特征与样本集中的对应特征进行比较，然后模型提取数据集中特征最为相似的数据（最近邻）为新数据赋予合适的标签。\n",
    "\n",
    "一般来说，模型会选择样本数据中前$k$个最相似的数据，根据这$k$个数据出现最多的分类，作为新数据的分类。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9151c1e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import operator\n",
    "\n",
    "def createDataSet():\n",
    "    group = np.array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])\n",
    "    labels = ['A','A','B','B']\n",
    "    return group, labels\n",
    "\n",
    "def classify0(inX, dataSet, labels, k):\n",
    "    dataSetSize = dataSet.shape[0]\n",
    "    diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet  # 用测试点分别与数据集相减\n",
    "    sqDiffMat = diffMat**2\n",
    "    sqDistances = sqDiffMat.sum(axis=1)\n",
    "    distances = sqDistances**0.5\n",
    "    sortedDistIndicies = distances.argsort() ## 对数据进行升序排序后，顺带返回对应的下标\n",
    "    \n",
    "    classCount={}\n",
    "    for i in range(k):\n",
    "        voteIlabel = labels[sortedDistIndicies[i]]\n",
    "        classCount[voteIlabel] = classCount.get(voteIlabel, 0)+1\n",
    "    \n",
    "    # iteritems返回的是一个迭代器,是以字典的键值对组成的键值对列表(但其好像是python2的函数，python3不可用了)\n",
    "    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)\n",
    "    return sortedClassCount[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7d5c12db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [1 2 3]]\n"
     ]
    }
   ],
   "source": [
    "# tile函数用于快速复制列表类结构，当只有一个参数时，表示将所有元素复制*次，当有两个参数时（[a,b]），表示将结构按行复制a次，再复制b次\n",
    "a = [1, 2, 3]\n",
    "b = np.tile(a, (2, 1))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fb02fc6",
   "metadata": {},
   "source": [
    "classify0()函数有四个输入参数：用于分类（测试）的向量inX，输入的训练样本集dataSet， 标签向量labels，表示邻居数目的参数$k$。上面程序使用的是欧氏距离计算公式，计算两点间的距离如下：\n",
    "\n",
    "$$ d = \\sqrt{(yA-yB)^2+(xA-xB)^2}$$\n",
    "\n",
    "例如：如果数据点存在四个特征值，则点$(1,0,0,1)$与$(7,6,9,4)$之间的距离计算为：\n",
    "\n",
    "$$ \\sqrt{(7-1)^2+(6-0)^2+(9-0)^2+(4-1)^2} $$\n",
    "\n",
    "计算完所有点的距离后，根据距离长短从小到大排序，确定前k个距离的最小元素所在的主要分类，存入classCount字典中计数。最后将该字典分解为元组列表，然后使用operator.itemgetter选择value，按照计数的大小进行降序排序。\n",
    "\n",
    "下面是测试："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "31955dce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'B'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group, labels = createDataSet()\n",
    "classify0([0,0], group, labels, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d26578cf",
   "metadata": {},
   "source": [
    "到现在k邻近算法已经可以正常使用了，但其实并没有多大用处，因为为该算法（模型）提供的数据集并没有实际意义。后面将用模型会对真实数据进行评估。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35333cc0",
   "metadata": {},
   "source": [
    "## 示例，使用k-近邻算法改进约会网站的配对结果"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07111e84",
   "metadata": {},
   "source": [
    "本示例目标是将收集到的数据按照：\n",
    "- 不喜欢的人\n",
    "- 魅力一般的人\n",
    "- 极具魅力的人\n",
    "\n",
    "进行分类"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63c311d2",
   "metadata": {},
   "source": [
    "一般机器学习分为以下几步：\n",
    "1. 收集数据：提供文本文件 \n",
    "2. 准备数据：使用python解析文本文件\n",
    "3. 分析数据：使用Mathplotlib绘图分析\n",
    "4. 训练算法：（不适合KNN算法）\n",
    "5. 测试算法\n",
    "6. 投入使用"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f878c0eb",
   "metadata": {},
   "source": [
    "### 准备数据："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87fb1946",
   "metadata": {},
   "source": [
    "数据文件已从网上下载，接着直接解析数据文件即可：\n",
    "\n",
    "收集的数据放在了文本文件datingTestSet.txt中，每个样本数据占据一行，共1000行，样本数据中包含三个特征，分别是：\n",
    "- 每年获得的飞行常客的里程数\n",
    "- 玩视频游戏所耗时间的百分比\n",
    "- 每周消费冰淇淋的公开数\n",
    "\n",
    "并且在数据集文件中，每一行的最后一个元素是该项数据的正确分类，即标签。\n",
    "\n",
    "接下来将构造一个处理数据的函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ffd76a51",
   "metadata": {},
   "outputs": [],
   "source": [
    "def file2matrix(filename):\n",
    "    with open(filename, 'r', encoding='utf-8') as fr:\n",
    "        arrayOLines = fr.readlines()\n",
    "        numberOfLines = len(arrayOLines)\n",
    "    returnMat = np.zeros((numberOfLines, 3))\n",
    "    classLabelVector = []\n",
    "    index = 0\n",
    "    for line in arrayOLines:\n",
    "        line = line.strip()\n",
    "        listFromLine = line.split('\\t')\n",
    "        returnMat[index,:] = listFromLine[0:3]\n",
    "        classLabelVector.append(int(listFromLine[-1]))\n",
    "        index+=1\n",
    "    \n",
    "    return returnMat, classLabelVector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0be74daf",
   "metadata": {},
   "source": [
    "接着，测试该数据预处理函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "34a1b062",
   "metadata": {},
   "outputs": [],
   "source": [
    "datingDataMat, datingLabels = file2matrix('resources/datingTestSet.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e66cbd",
   "metadata": {},
   "source": [
    "将文本文件的数据导入后，我们可以检查一下是否成功："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "75fc49a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4.0920000e+04 8.3269760e+00 9.5395200e-01]\n",
      " [1.4488000e+04 7.1534690e+00 1.6739040e+00]\n",
      " [2.6052000e+04 1.4418710e+00 8.0512400e-01]\n",
      " ...\n",
      " [2.6575000e+04 1.0650102e+01 8.6662700e-01]\n",
      " [4.8111000e+04 9.1345280e+00 7.2804500e-01]\n",
      " [4.3757000e+04 7.8826010e+00 1.3324460e+00]]\n"
     ]
    }
   ],
   "source": [
    "print(datingDataMat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6a959eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1, 1, 1, 1, 3, 3, 1, 3, 1, 1, 2, 1, 1, 1, 1, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(datingLabels[:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b26ebddc",
   "metadata": {},
   "source": [
    "### 分析数据 ：Matplotlib创建散点图"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87e2400e",
   "metadata": {},
   "source": [
    "下面用matplotlib制作原始数据散点图：\n",
    "\n",
    "首先先介绍一下一些函数的用法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3085a975",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.figure(figsize=(4,3))\n",
    "fig.add_subplot(111)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cf3055",
   "metadata": {},
   "source": [
    "figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)\n",
    "\n",
    "参数解释\n",
    "- **num：** 图像编号或名称，数字为编号 ，字符串为名称\n",
    "- **figsize：** 指定figure的宽和高，单位为英寸；\n",
    "- **dpi：** 参数指定绘图对象的分辨率，即每英寸多少个像素，缺省值为80      1英寸等于2.5cm,A4纸是 21*30cm的纸张 \n",
    "- **facecolor：** 背景颜色\n",
    "- **edgecolor：** 边框颜色\n",
    "- **frameon：** 是否显示边框\n",
    "\n",
    "上面函数像是定义了一个主背景，add_subplot则是为主背景添加相应的子图，可以看到，参数是三位数，有点奇怪，但其实有其含义：\n",
    "- 参数1：子位图总行数\n",
    "- 参数2：子位图总列数\n",
    "- 参数3：子位图所在位置\n",
    "\n",
    "可以这样理解，前两个参数定义主背景的宽（高/行数）和长（列数），第三个参数代表子图的位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e577e4a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.family'] = 'SimHei' \n",
    "fig = plt.figure(figsize=(7,5))\n",
    "ax = fig.add_subplot(111)\n",
    "ax.scatter(datingDataMat[:, 1], datingDataMat[:, 2])\n",
    "plt.ylabel(\"每周消费冰淇淋的公开数\")\n",
    "plt.xlabel(\"玩视频游戏所耗时间的百分比\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "329b84eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7,5))\n",
    "ax = fig.add_subplot(111)\n",
    "ax.scatter(datingDataMat[:, 1], datingDataMat[:, 2], 15.0*np.array(datingLabels), 15.0*np.array(datingLabels))\n",
    "plt.ylabel(\"每周消费冰淇淋的公开数\")\n",
    "plt.xlabel(\"玩视频游戏所耗时间的百分比\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5a535ed5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17a6542a6d8>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7,5))\n",
    "ax = fig.add_subplot(111)\n",
    "datingLabels = np.array(datingLabels)\n",
    "id1 = np.where(datingLabels==1)\n",
    "id2 = np.where(datingLabels==2)\n",
    "id3 = np.where(datingLabels==3)\n",
    "ax.scatter(datingDataMat[id1, 0], datingDataMat[id1, 1],  15.0*datingLabels, label = \"不喜欢\")\n",
    "ax.scatter(datingDataMat[id2, 0], datingDataMat[id2, 1],  15.0*datingLabels, label = \"魅力一般\")\n",
    "ax.scatter(datingDataMat[id3, 0], datingDataMat[id3, 1],  15.0*datingLabels, label = \"极具魅力\")\n",
    "ax.set_ylabel(\"玩视频游戏所耗时间的百分比\")\n",
    "ax.set_xlabel(\"每年获取的飞行常客里程数\")\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5ec911f",
   "metadata": {},
   "source": [
    "### 准备数据： 归一化数值"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65070c1e",
   "metadata": {},
   "source": [
    "下面是约会网站原始数据改进后的部分样本数据：\n",
    "\n",
    "|    | 玩视频游戏所耗时间的百分比 | 每年获取的飞行常客里程数 | 每周消费冰淇淋的公开数 | 样本分类 |\n",
    "|:----|:----:|:----:|:----:|:----:|\n",
    "|1|0.8|400|0.5|1|\n",
    "|2|12|134000|0.9|3|\n",
    "|3|0|20000|1.1|2|\n",
    "|4|67|32000|0.1|2|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29be0fa3",
   "metadata": {},
   "source": [
    "通过上表给出的数据，如果我们要计算数据3和4之间的距离，即：\n",
    "\n",
    "$$\\sqrt{(0-67)^2+(20000-32000)^2+(1.1-0.1)^2}$$\n",
    "\n",
    "这时发现，上面数字差值最大的属性（特征）对计算结果的影响最大，即**每年回去的飞行常客里程数**这个特征对于计算结果的影响占绝大部分，因此在不舍去任何特征的情况下，应该想办法消除某一特征值影响计算结果这一现象。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a159274",
   "metadata": {},
   "source": [
    "一般在处理不同取值范围的特征值是，通常采用**数值归一化**。比如将取值范围处理至0到1或者-1到1之间。数值归一化是对全体特征值进行的操作，并非对单一特征值进行操作。用下面的公式可以将任意取值范围的特征值转化为0到1区间内的值：\n",
    "\n",
    "$$newValue = (oldValue-min)/(max-min)$$\n",
    "\n",
    "公式中min和max代表数据集中的最小特征值和最大特征值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6cd03134",
   "metadata": {},
   "outputs": [],
   "source": [
    "def autoNorm(dataSet):\n",
    "    minVals = dataSet.min(0) ## 这是numpy中的max和min函数，参数表示操作的轴，例如此时操作的是列，返回的是列中最小的元素\n",
    "    maxVals = dataSet.max(0)\n",
    "    ranges = maxVals-minVals\n",
    "    normDataSet = np.zeros(np.shape(dataSet))\n",
    "    m = dataSet.shape[0]  ## shape返回的是一个元组，储存该矩阵有几行几列\n",
    "    normDataSet = dataSet-np.tile(minVals, (m, 1))\n",
    "    normDataSet /= np.tile(ranges, (m, 1))\n",
    "    return normDataSet, ranges, minVals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a412c3e",
   "metadata": {},
   "source": [
    "*tips: norm 意为标准*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "94385e84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.44832535 0.39805139 0.56233353]\n",
      " [0.15873259 0.34195467 0.98724416]\n",
      " [0.28542943 0.06892523 0.47449629]\n",
      " ...\n",
      " [0.29115949 0.50910294 0.51079493]\n",
      " [0.52711097 0.43665451 0.4290048 ]\n",
      " [0.47940793 0.3768091  0.78571804]]\n"
     ]
    }
   ],
   "source": [
    "normMat, ranges, minVals = autoNorm(datingDataMat)\n",
    "print(normMat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dff95b66",
   "metadata": {},
   "source": [
    "可以看到，现在第二个特征值也不再是巨大的数了（相对于其他两个特征）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b66d5a9",
   "metadata": {},
   "source": [
    "### 测试算法： "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae233eca",
   "metadata": {},
   "source": [
    "下面将构造一个测试模型正确性的函数datingClassTest:\n",
    "\n",
    "*tips：该函数中对训练集和测试集的划分并没有随机取，并且比例为9:1*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cf426bf3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 3\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 3, the real answer is: 1\n",
      "the total error rate is: 0.050000\n"
     ]
    }
   ],
   "source": [
    "def datingClassTest():\n",
    "    hoRatio = 0.1  ## 测试集的划分比例 该处用9/1开\n",
    "    datingDataMat, datingLabels = file2matrix('resources/datingTestSet.txt')\n",
    "    normMat, ranges, minVals = autoNorm(datingDataMat)\n",
    "    m = normMat.shape[0]\n",
    "    numTestVecs = int(m*hoRatio)\n",
    "    errorCount = 0.0\n",
    "    for i in range(numTestVecs):\n",
    "        ## 第一个参数为测试集，第二个为训练集，第三个为训练集包含的标签，第四个设置邻居数\n",
    "        classifierResult = classify0(normMat[i,:], normMat[numTestVecs:m,:], datingLabels[numTestVecs:m], 3)\n",
    "        print(\"the classifier came back with: {:d}, the real answer is: {:d}\".format(classifierResult, datingLabels[i]))\n",
    "        if classifierResult != datingLabels[i]:\n",
    "            errorCount+=1.0\n",
    "    \n",
    "    print(\"the total error rate is: {:f}\".format(errorCount/numTestVecs)) ## 在python3中，/是真正意义上的除法，若要取整则使用//\n",
    "    \n",
    "datingClassTest()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da771905",
   "metadata": {},
   "source": [
    "### 使用算法："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f845bfa",
   "metadata": {},
   "source": [
    "下面构建一个函数，进行一个简单的交互式包装："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e84aee46",
   "metadata": {},
   "outputs": [],
   "source": [
    "def classifyPerson():\n",
    "    resultList = ['not at all','in small doses','in large doses']\n",
    "    percentTats = float(input(\"percentage of time spent playing video games?\"))\n",
    "    ffmiles = float(input(\"frequent flier miles earned per year?\"))\n",
    "    iceCream = float(input(\"liters of ice-cream consumed per year?\"))\n",
    "    datingDataMat, datingLabels = file2matrix('resources/datingTestSet.txt')\n",
    "    normMat, ranges, minVals = autoNorm(datingDataMat)\n",
    "    inArr = np.array([ffmiles,percentTats,iceCream])\n",
    "    classifierResult = classify0((inArr-minVals)/ranges,normMat, datingLabels, 3)\n",
    "    print(resultList[classifierResult-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd29cc7",
   "metadata": {},
   "source": [
    "## 示例：手写识别系统"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6250d5a",
   "metadata": {},
   "source": [
    "该示例构造的系统只能识别0到9的手写体数字，且手写体数字已使用图像识别软件构造成具有相同大小和颜色的32*32大小的二进制文本文件（只有0和1组成的txt文件）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e651d92",
   "metadata": {},
   "source": [
    "### 准备数据：将图像转换为测试向量"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77f35116",
   "metadata": {},
   "source": [
    "图像数据储存在resource/digits目录中，其中trainingDigits包含了2000个例子，每个数字大约有200个样本；目录testDigits中包含了900条数据。这两组数据作用字如其意。\n",
    "\n",
    "为了使用这些图像，我们必须将图像数据格式化为一个向量。也就是说，将32*32的二进制图像转化为1*1024的向量，这样才可以使用KNN算法处理图像信息了。\n",
    "\n",
    "我们先编写一个函数img2vector,其实道理很简单，就是将32*32的矩阵展开而已"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8e6c8bca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def img2vector(filename):\n",
    "    returnVect = np.zeros((1, 1024))\n",
    "    fr = open(filename)\n",
    "    for i in range(32):\n",
    "        lineStr = fr.readline()\n",
    "        for j in range(32):\n",
    "            returnVect[0, 32*i+j] = int(lineStr[j])\n",
    "    \n",
    "    return returnVect"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf2c9452",
   "metadata": {},
   "source": [
    "接下来测试img2vector函数： (其实不用测试也行，大伙用肉眼也能看出来结果)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b3b1d0f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 1. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 1. 1. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "testVector = img2vector('resources/digits/testDigits/0_13.txt')\n",
    "print(testVector[0,:32])\n",
    "print(testVector[0,32:64])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec973391",
   "metadata": {},
   "source": [
    "### 测试算法：使用k-近邻算法识别手写数字"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ddd12e3",
   "metadata": {},
   "source": [
    "手写数字识别系统的测试代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f7915442",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 0, the real answer is: 0\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 7, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 1, the real answer is: 1\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 2, the real answer is: 2\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 9, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 3, the real answer is: 3\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 4, the real answer is: 4\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 3, the real answer is: 5\n",
      "the classifier came back with: 6, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 5, the real answer is: 5\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 6, the real answer is: 6\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 7, the real answer is: 7\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 6, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 3, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 1, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 1, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 8, the real answer is: 8\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 1, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 7, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the classifier came back with: 9, the real answer is: 9\n",
      "the total number of errors is: 10\n",
      "the total error rate is: 0.010571\n"
     ]
    }
   ],
   "source": [
    "from os import listdir\n",
    "\n",
    "def handwritingClassTest():\n",
    "    hwLabels = []\n",
    "    trainingFileList = listdir('resources/digits/trainingDigits')\n",
    "    m = len(trainingFileList)  ##训练集数据个数\n",
    "    trainingMat = np.zeros((m, 1024))\n",
    "    for i in range(m):\n",
    "        fileNameStr = trainingFileList[i]\n",
    "        fileStr = fileNameStr.split('.')[0]  \n",
    "        classNumStr = int(fileStr.split('_')[0])  ## 测试的数字（答案/标签）\n",
    "        hwLabels.append(classNumStr)\n",
    "        trainingMat[i,:] = img2vector('resources/digits/trainingDigits/{:s}'.format(fileNameStr))\n",
    "    testFileList = listdir('resources/digits/testDigits')\n",
    "    errorCount = 0\n",
    "    mTest = len(testFileList)  ## 测试集数据个数\n",
    "    for i in range(mTest):\n",
    "        fileNameStr = testFileList[i]\n",
    "        fileStr = fileNameStr.split('.')[0]\n",
    "        classNumStr = int(fileStr.split('_')[0])\n",
    "        vectorUnderTest = img2vector('resources/digits/testDigits/{:s}'.format(fileNameStr))\n",
    "        classifierResult = classify0(vectorUnderTest,trainingMat,hwLabels,3)\n",
    "        print(\"the classifier came back with: {:d}, the real answer is: {:d}\".format(classifierResult, classNumStr))\n",
    "        if classifierResult != classNumStr: \n",
    "            errorCount+=1\n",
    "    \n",
    "    print(\"the total number of errors is: {:d}\".format(errorCount))\n",
    "    print(\"the total error rate is: {:f}\".format(errorCount/mTest))\n",
    "    \n",
    "handwritingClassTest()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfcd719b",
   "metadata": {},
   "source": [
    "实际使用k-近邻算法时，效率很低。对本例来说，算法需要对每个输入数据点进行2000次欧式距离计算，每个距离计算又包括1024个维度的运算，每个数字又有100个样本，一共需要测试900次（调用900次classify0函数）。并且从空间上，储存这些图像数据又要花2MB大小的储存空间。可以说是非常难受了。不过，**k决策树**可以节省大量计算开销，其是k-近邻算法的优化版。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63772f87",
   "metadata": {},
   "source": [
    "## 本章小结"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b27fd12",
   "metadata": {},
   "source": [
    "k-近邻算法是分类数据的最简单有效的算法。但其缺点非常明显，在使用算法时必须有接近实际数据的训练样本，并且使用算法时必须保存全部的数据集，必须对每个数据集中的每个特征进行距离计算，在实际使用时非常耗费空间和时间。\n",
    "\n",
    "k-近邻算法的另外一个缺点是无法给出任何数据的基础结构信息，因此我们也无法知晓平均实例样本和典型实例样本具有什么特征。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
